home *** CD-ROM | disk | FTP | other *** search
/ Computer Select (Limited Edition) / Computer Select.iso / msj / v07n02 / netbios.exe / SESSION.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-01  |  8.1 KB  |  316 lines
  1. /***************************************************************************
  2.  *  SESSION.C                                   *
  3.  *    This file contains following NetBIOS Session related functions       *
  4.  *                                       *
  5.  *      SendSess   () :- Sends data on an established session        *
  6.  *      ReceiveSess() :- Receives data for a given session           *
  7.  *      HangSess   () :- Terminate  a given session               *
  8.  *      Call()    :- Establish a session with a remote name       *
  9.  *      Listen()    :- Put yourself in "listening" state to receive    *
  10.  *               remote calls.                   *
  11.  *                                       *
  12.  *  History:    Alok Sinha  October, 1991    Created               *
  13.  *                                       *
  14.  ***********************************************************************/
  15.  
  16. // Include files
  17. #include <ncb.h>
  18. #include <common.h>
  19. #include <namesrv.h>
  20. #include <session.h>
  21. #include <memory.h>
  22. #include <string.h>
  23.  
  24.  
  25. /*
  26.  * FUNCTION    :: SendSess()
  27.  * PARAMETERS  ::
  28.  *     [in]  ucLana      :- LAN Adaptor number
  29.  *     [in]  ucLsn      :- Local Session Number
  30.  *     [in]  pchData      :- pointer to a data buffer to send
  31.  *     [in]  usDataLen  :- data buffer length.
  32.  *
  33.  * Comment:
  34.  *        This function will execute synchronous NCB.SEND command.
  35.  *
  36.  * RETURN VALUE:
  37.  *        NO_ERROR if no errors were encountered, else error returned from
  38.  *        NetBIOS call in Retcode field.
  39.  */
  40.  
  41. unsigned char    SendSess(     unsigned char ucLana,
  42.                   unsigned char ucLsn,
  43.                   char far * pchData,
  44.                   unsigned short usDataLen
  45.             )
  46. {
  47.     NCB Ncb;
  48.     unsigned char ucRc;
  49.  
  50.     /* First clear out the buffer */
  51.     ClearNcb ( &Ncb);
  52.  
  53.     /*    Set the Command. Synchronous NCB.SEND */
  54.     Ncb.ncb_command = NCBSEND;
  55.  
  56.     /* set the LAN Adaptor number */
  57.     Ncb.ncb_lana_num = ucLana;
  58.  
  59.     /* set the Local Session Number */
  60.     Ncb.ncb_lsn = ucLsn;
  61.  
  62.     /* Set  Data buffer pointer and it's length */
  63.     Ncb.ncb_buffer = pchData;
  64.     Ncb.ncb_length = usDataLen;
  65.  
  66.     /* Make the OS dependent NetBIOS call */
  67.     if ((ucRc=NetBiosRequest ( &Ncb))!= NO_ERROR)
  68.     return ucRc ;
  69.  
  70.     return Ncb.ncb_retcode;
  71.  
  72. }
  73.  
  74.  
  75. /*
  76.  * FUNCTION    :: ReceiveSess()
  77.  * PARAMETERS  ::
  78.  *     [in]  ucLana      :- Lan Adaptor number
  79.  *     [in]  ucLsn      :- Local Session Number
  80.  *     [in]  pchData      :- pointer to a data buffer to send
  81.  *     [in/out]pusDataLen  :- This is set to data buffer length when
  82.  *                called by application. And it is set by
  83.  *                to data buffer size actually received, if call
  84.  *                completes successfully.
  85.  * Comment:
  86.  *        This function will execute synchronous NCB.RECEIVE command.
  87.  *
  88.  * RETURN VALUE:
  89.  *        NO_ERROR if no errors were encountered, else error returned from
  90.  *        NetBIOS call in Retcode field.
  91.  */
  92.  
  93. unsigned char    ReceiveSess(    unsigned char ucLana,
  94.                 unsigned char ucLsn,
  95.                 char far * pchData,
  96.                 unsigned short *pusDataLen
  97.                )
  98. {
  99.     NCB Ncb;
  100.     unsigned char ucRc;
  101.  
  102.     /* First clear out the buffer */
  103.     ClearNcb ( &Ncb);
  104.  
  105.     /*    Set the Command synchronous NCB.RECEIVE */
  106.     Ncb.ncb_command = NCBRECV;
  107.  
  108.     /* set the LAN Adaptor number */
  109.     Ncb.ncb_lana_num = ucLana;
  110.  
  111.     /* set the Local Session Number */
  112.     Ncb.ncb_lsn = ucLsn;
  113.  
  114.     /* Set  Data buffer pointer and it's length */
  115.     Ncb.ncb_buffer = pchData;
  116.     Ncb.ncb_length = *pusDataLen;
  117.  
  118.     /* Make the OS dependent NetBIOS call */
  119.     if ((ucRc=NetBiosRequest ( &Ncb))!= NO_ERROR)
  120.     return ucRc ;
  121.  
  122.     /* return actual size of data buffer if call was successful */
  123.     if (Ncb.ncb_retcode == NO_ERROR)
  124.     *pusDataLen = Ncb.ncb_length;
  125.  
  126.     return Ncb.ncb_retcode;
  127.  
  128. }
  129.  
  130. /*
  131.  * FUNCTION    :: HangSess()
  132.  * PARAMETERS  ::
  133.  *     [in]  ucLana      :- Lan Adaptor number
  134.  *     [in]  ucLsn      :- Local Session Number
  135.  *
  136.  * Comment:
  137.  *        This function will execute synchronous NCB.HANGUP command.
  138.  *
  139.  * RETURN VALUE:
  140.  *        NO_ERROR if no errors were encountered, else error returned from
  141.  *        NetBIOS call in Retcode field.
  142.  */
  143.  
  144. unsigned char    HangSess(   unsigned char ucLana,
  145.                 unsigned char ucLsn
  146.             )
  147. {
  148.     NCB Ncb;
  149.     unsigned char ucRc;
  150.  
  151.     /* First clear out the buffer */
  152.     ClearNcb ( &Ncb);
  153.  
  154.     /*    Set the Command synchronous NCB.HANGUP */
  155.     Ncb.ncb_command = NCBHANGUP;
  156.  
  157.     /* set the LAN Adaptor number */
  158.     Ncb.ncb_lana_num = ucLana;
  159.  
  160.     /* set the Local Session Number */
  161.     Ncb.ncb_lsn = ucLsn;
  162.  
  163.     /* Make the OS dependent NetBIOS call */
  164.     if ((ucRc=NetBiosRequest ( &Ncb))!= NO_ERROR)
  165.     return ucRc ;
  166.  
  167.     return Ncb.ncb_retcode;
  168.  
  169. }
  170.  
  171.  
  172. /*
  173.  * FUNCTION    :: Call()
  174.  * PARAMETERS  ::
  175.  *     [in]  ucLana         :- Lan Adaptor number
  176.  *     [in]  pchRemoteName :- Remote name to connect to.
  177.  *     [in]  pchLocalName  :- Local  (process) name.
  178.  *     [in]  ucSto         :- Send    Time Out in 1/2 seconds units
  179.  *     [in]  ucRto         :- Receive Time Out in 1/2 seconds units
  180.  *     [out] ucLsn         :- Local Session Number on successful
  181.  *                completion.
  182.  *
  183.  * Comment:
  184.  *        This function will execute synchronous NCB.CALL command.
  185.  *
  186.  * RETURN VALUE:
  187.  *        NO_ERROR if no errors were encountered, else error returned from
  188.  *        NetBIOS call in Retcode field.
  189.  */
  190.  
  191. unsigned char    Call(     unsigned char ucLana,
  192.              char far * pchRemoteName,
  193.              char far * pchLocalName,
  194.              unsigned char ucSto,
  195.              unsigned char ucRto,
  196.              unsigned char far *ucLsn
  197.             )
  198. {
  199.     NCB Ncb;
  200.     unsigned char ucRc;
  201.  
  202.     /* First clear out the buffer */
  203.     ClearNcb ( &Ncb);
  204.  
  205.     /*    Set the Command synchronous NCB.CALL */
  206.     Ncb.ncb_command = NCBCALL;
  207.  
  208.     /* set the LAN Adaptor number */
  209.     Ncb.ncb_lana_num = ucLana;
  210.  
  211.     /* Set Remote name in ncb_callname */
  212.     memcpy(&Ncb.ncb_callname[0], pchRemoteName, NCBNAMSZ);
  213.  
  214.     /* Set Local name in ncb_name */
  215.     memcpy(&Ncb.ncb_name[0], pchLocalName, NCBNAMSZ);
  216.  
  217.     /* set the Send Time Out*/
  218.     Ncb.ncb_sto = ucSto;
  219.  
  220.     /* set the Receive Time Out*/
  221.     Ncb.ncb_sto = ucRto;
  222.  
  223.     /* Make the OS dependent NetBIOS call */
  224.     if ((ucRc=NetBiosRequest ( &Ncb))!= NO_ERROR)
  225.     return ucRc ;
  226.  
  227.     /* Return the Local Session Number */
  228.     if (Ncb.ncb_retcode == NO_ERROR)
  229.     *ucLsn = Ncb.ncb_lsn;
  230.  
  231.     return Ncb.ncb_retcode;
  232.  
  233. }
  234.  
  235. /*
  236.  * FUNCTION    :: Listen()
  237.  * PARAMETERS  ::
  238.  *     [in]  ucLana         :- Lan Adaptor number
  239.  *     [in/out] pchRemoteName :- Remote name to connect to. If this
  240.  *                   is set to '*', NetBIOS will return
  241.  *                   name of calling process.
  242.  *
  243.  *     [in]  pchLocalName  :- Local  (process) name.
  244.  *     [in]  ucSto         :- Send    Time Out in 1/2 seconds units
  245.  *     [in]  ucRto         :- Receive Time Out in 1/2 seconds units
  246.  *     [out] ucLsn         :- Local Session Number on successful
  247.  *                completion.
  248.  *
  249.  * Comment:
  250.  *        This function will execute synchronous NCB.CALL command.
  251.  *
  252.  * RETURN VALUE:
  253.  *        NO_ERROR if no errors were encountered, else error returned from
  254.  *        NetBIOS call in Retcode field.
  255.  */
  256. unsigned char    Listen(     unsigned char ucLana,
  257.              char far * pchRemoteName,
  258.              char far * pchLocalName,
  259.              unsigned char ucSto,
  260.              unsigned char ucRto,
  261.              unsigned char far *ucLsn
  262.              )
  263. {
  264.     NCB Ncb;
  265.     unsigned char ucRc;
  266.     BOOL     fReturnCallerName;
  267.  
  268.  
  269.     /* First clear out the buffer */
  270.     ClearNcb ( &Ncb);
  271.  
  272.     /*    Set the Command synchronous NCB.LISTEN */
  273.     Ncb.ncb_command = NCBLISTEN;
  274.  
  275.     /* set the LAN Adaptor number */
  276.     Ncb.ncb_lana_num = ucLana;
  277.  
  278.     /* Set Remote name in ncb_callname */
  279.     if (pchRemoteName[0]='*')
  280.     {
  281.     Ncb.ncb_callname[0]='*';
  282.     fReturnCallerName = TRUE;
  283.     }
  284.     else
  285.     {
  286.     memcpy(&Ncb.ncb_callname[0], pchRemoteName, NCBNAMSZ);
  287.     fReturnCallerName = FALSE;
  288.     }
  289.  
  290.     /* Set Local name in ncb_name */
  291.     memcpy(Ncb.ncb_name, pchLocalName, NCBNAMSZ);
  292.  
  293.     /* set the Send Time Out*/
  294.     Ncb.ncb_sto = ucSto;
  295.  
  296.     /* set the Receive Time Out*/
  297.     Ncb.ncb_sto = ucRto;
  298.  
  299.     /* Make the OS dependent NetBIOS call */
  300.     if ((ucRc=NetBiosRequest ( &Ncb))!= NO_ERROR)
  301.     return ucRc ;
  302.  
  303.     /* Return the Local Session Number
  304.      * and return caller's name if pchRemoteName was set '*'
  305.      */
  306.     if (Ncb.ncb_retcode == NO_ERROR)
  307.     {
  308.     *ucLsn = Ncb.ncb_lsn;
  309.     if (fReturnCallerName)
  310.         memcpy(pchRemoteName, Ncb.ncb_callname, NCBNAMSZ);
  311.     }
  312.  
  313.     return Ncb.ncb_retcode;
  314.  
  315. }
  316.